// Copyright (C) 2018-2024 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//

#pragma once

#include <cstddef>
#include <cstdint>

namespace kernel_selector {
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// KernelType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class KernelType {
    UNKNOWN,
    ARG_MAX_MIN,
    BEAM_TABLE_UPDATE,
    CONVOLUTION,
    DECONVOLUTION,
    DFT,
    LRN,
    NORMALIZE,
    POOLING,
    RANGE,
    ROI_POOLING,
    ROI_ALIGN,
    ROLL,
    FULLY_CONNECTED,
    ACTIVATION,
    SOFT_MAX,
    ELTWISE,
    REORDER,
    RESHAPE,
    COUNT_NONZERO,
    GATHER_NONZERO,
    GROUP_NORMALIZATION,
    PERMUTE,
    CONCATENATION,
    RESAMPLE,
    REGION_YOLO,
    REORG_YOLO,
    MVN,
    LSTM_ELT,
    BORDER,
    TILE,
    SELECT,
    BROADCAST,
    BUCKETIZE,
    GEMM,
    GRID_SAMPLE,
    CONTRACT,
    ONE_HOT,
    GATHER,
    GATHER_ND,
    GATHER_ELEMENTS,
    SCATTER_UPDATE,
    SCATTER_ND_UPDATE,
    SCATTER_ELEMENTS_UPDATE,
    DEPTH_TO_SPACE,
    BATCH_TO_SPACE,
    SHAPE_OF,
    SDPA,
    SHUFFLE_CHANNELS,
    SLICE,
    STRIDED_SLICE,
    REVERSE_SEQUENCE,
    QUANTIZE,
    REDUCE,
    GATHER_TREE,
    SPACE_TO_DEPTH,
    SPACE_TO_BATCH,
    GRN,
    CTC_GREEDY_DECODER,
    CTC_LOSS,
    CUM_SUM,
    EMBEDDING_BAG,
    EXTRACT_IMAGE_PATCHES,
    LOOP,
    NON_MAX_SUPPRESSION,
    DETECTION_OUTPUT,
    EXPERIMENTAL_DETECTRON_DETECTION_OUTPUT,
    EXPERIMENTAL_DETECTRON_GENERATE_PROPOSALS_SINGLE_IMAGE,
    EXPERIMENTAL_DETECTRON_PRIOR_GRID_GENERATOR,
    EXPERIMENTAL_DETECTRON_ROI_FEATURE_EXTRACTOR,
    EXPERIMENTAL_DETECTRON_TOPK_ROIS,
    CONVERT_COLOR,
    RANDOM_UNIFORM,
    ADAPTIVE_POOLING,
    MATRIX_NMS,
    REVERSE,
    PRIOR_BOX,
    EYE,
    GENERATE_PROPOSALS,
    MULTICLASS_NMS,
    MULTINOMIAL,
    UNIQUE_COUNT,
    UNIQUE_GATHER,
    RMS,
    SWIGLU,
    ROPE
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Datatype
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class Datatype {
    UNSUPPORTED,
    UINT4,
    INT4,
    INT8,
    UINT8,
    INT16,
    UINT16,
    INT32,
    UINT32,
    INT64,
    F16,
    F32,
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WeightsType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class WeightsType {
    UNSUPPORTED,
    F16,
    F32,
    INT8,
    UINT8,
    UINT4,
    INT4,
    INT32
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// NonLinearActivation
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class ActivationFunction {
    LOGISTIC,
    HYPERBOLIC_TAN,
    RELU,
    RELU_NEGATIVE_SLOPE,
    CLAMP,
    SOFTRELU,
    ABS,
    SQUARE,
    SQRT,
    LINEAR,
    ELU,
    SIN,
    ASIN,
    SINH,
    ASINH,
    COS,
    ACOS,
    COSH,
    LOG,
    ACOSH,
    LOG2,
    EXP,
    NONE,
    TAN,
    ATAN,
    ATANH,
    FLOOR,
    CEIL,
    NEGATIVE,
    NOT,
    POW,
    ERF,
    HARD_SIGMOID,
    HSIGMOID,
    RECIPROCAL,
    SELU,
    SIGN,
    SOFTPLUS,
    SOFTSIGN,
    SWISH,
    HSWISH,
    MISH,
    GELU,
    GELU_TANH,
    ROUND_HALF_TO_EVEN,
    ROUND_HALF_AWAY_FROM_ZERO
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// PoolType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class PoolType {
    MAX,
    AVG,
    BILINEAR,
    DEFORMABLE_BILINEAR
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// PoolRemainder
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class PoolRemainder {
    FLOOR,
    CEIL
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// LRNMode
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class LRNMode {
    ACROSS_CHANNEL,
    WITHIN_CHANNEL
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ArgMaxMinDim
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class ArgMaxMinAxis {
    BATCH,
    FEATURE,
    X,
    Y,
    Z
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ArgMaxMinOut
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class ArgMaxMinOut {
    MAX,
    MIN
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ArgMaxMinSortType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class ArgMaxMinSortType {
    VALUE,
    INDEX
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// NormalizeMode
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class NormalizeMode {
    ACROSS_SPATIAL,
    WITHIN_SPATIAL
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// MVNMode
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class MVNMode {
    ACROSS_CHANNELS,
    WITHIN_CHANNELS
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// MVNEpsMode
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class MVNEpsMode {
    INSIDE_SQRT,
    OUTSIDE_SQRT
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// LRNMode
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class KernelDividerMode {
    DONT_CARE,
    FIXED,
    DYNAMIC,
    DYNAMIC_WITH_PADDING
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// EltwiseMode
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class EltwiseMode {
    ADD,
    SUB,
    MUL,
    DIV,
    MIN,
    MAX,
    POW,
    MODULU,
    SQRT,
    RSQRT,
    ASSIGN,
    EQ,
    NE,
    LT,
    LE,
    GT,
    GE,
    LOGIC_AND,
    LOGIC_OR,
    LOGIC_XOR,
    SQUARED_DIFF,
    FLOOR_MOD,
    IS_FINITE,
    IS_INF,
    IS_NAN,
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// EltwiseInputMode
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class EltwiseInputMode {
    SCALAR,
    INPUT_BUFFER,
    UNORDERED_ACCESS_INPUT_BUFFER,
    INTERMEDIATE_RESULTS_INDEX,
    OUTPUT_BUFFER
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// SoftmaxDim
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class SoftmaxDim {
    X,
    Y,
    Z,
    FEATURE,
    BATCH,
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// MeanSubsructMode
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class MeanSubtractMode {
    NONE,
    INSIDE_PARAMS,  // the index is feature id (modulu size)
    IN_BUFFER,
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// MeanOp
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class MeanOp {
    NONE,
    SUB,
    MUL,
    DIV,
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ConcatAxis
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class ConcatAxis {
    X,
    Y,
    Z,
    W,
    FEATURE,
    BATCH
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// DepthToSpaceMode
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class DepthToSpaceMode {
    BLOCKS_FIRST,
    DEPTH_FIRST,
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ResampleType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class ResampleType {
    NEAREST_NEIGHBOR,
    BILINEAR_INTERP,
    CAFFE_BILINEAR_INTERP,
    CUBIC,
    LINEAR_ONNX,
    BILINEAR_PILLOW,
    BICUBIC_PILLOW,
};

enum class CoordinateTransformationMode {
    HALF_PIXEL,
    PYTORCH_HALF_PIXEL,
    ASYMMETRIC,
    TF_HALF_PIXEL_FOR_NN,
    ALIGN_CORNERS,
};

enum class NearestMode {
    ROUND_PREFER_FLOOR,
    ROUND_PREFER_CEIL,
    FLOOR,
    CEIL,
    SIMPLE,
};

enum class ShapeCalculationMode {
    SIZES,
    SCALES,
};

enum class InterpolateAxis {
    X,
    Y,
    Z,
    W,
    FEATURE,
    BATCH
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// BorderType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class BorderType {
    CONSTANT,
    EDGE,
    MIRROR,
    MIRROR_101,
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// IndexSelectAxis
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class IndexSelectAxis {
    BATCH,
    FEATURE,
    X,
    Y
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Size
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
template <typename T>
struct Size {
    T x = 0;
    T y = 0;
    T z = 0;

    Size() = default;
    Size(T x, T y, T z = 1) : x(x), y(y), z(z) {}
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// DimTensor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
template <typename T = std::uint32_t>
struct DimTensor {
    T b = 0;
    T f = 0;
    T w = 0;
    T z = 0;
    T y = 0;
    T x = 0;

    DimTensor() = default;
    DimTensor(T b, T f, T w, T z, T y, T x) : b(b), f(f), w(w), z(z), y(y), x(x) {}
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Aliases:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
using uSize = Size<std::uint32_t>;
using stSize = Size<std::size_t>;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ContractMode
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class ContractMode {
    SUM,
    PRODUCT,
    ALL,
    ANY,
    MAX,
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// GatherAxis
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class GatherAxis {
    X,
    Y,
    Z,
    W,
    FEATURE,
    BATCH,
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ScatterUpdateAxis
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class ScatterUpdateAxis {
    X,
    Y,
    Z,
    W,
    U,
    V,
    FEATURE,
    BATCH,
};
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ScatterUpdateReduction
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class ScatterUpdateReduction {
    NONE = 0,
    SUM,
    PROD,
    MIN,
    MAX,
    MEAN
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ReduceMode
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class ReduceMode {
    MAX,
    MIN,
    MEAN,
    PROD,
    SUM,
    AND,
    OR,
    SUM_SQUARE,
    L1,
    L2,
    LOG_SUM,
    LOG_SUM_EXP
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// QuantizationType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class QuantizationType {
    NONE,
    SYMMETRIC,
    ASYMMETRIC_WEIGHTS,
    ASYMMETRIC_DATA,
    ASYMMETRIC_DATA_AND_WEIGHTS
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// SpaceToDepthMode
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class SpaceToDepthMode {
    DEPTH_FIRST,
    BLOCKS_FIRST
};
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// CumSumAxis
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class CumSumAxis {
    X,
    Y,
    Z,
    W,
    FEATURE,
    BATCH
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// EmbeddingBagType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class EmbeddingBagType {
    PACKED_SUM,
    OFFSETS_SUM,
    SEGMENTS_SUM
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// BoxEncodingType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class BoxEncodingType {
    BOX_ENCODING_CORNER,
    BOX_ENCODING_CENTER,
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// NMSRotationType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class NMSRotationType {
    NONE,
    CLOCKWISE,
    COUNTERCLOCKWISE
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ConvertColor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class color_format : uint32_t {
    RGB,       ///< RGB color format
    BGR,       ///< BGR color format, default in OpenVINO
    RGBX,      ///< RGBX color format with X ignored during inference
    BGRX,      ///< BGRX color format with X ignored during inference
    NV12,      ///< NV12 color format represented as compound Y+UV blob
    I420,      ///< I420 color format represented as compound Y+U+V blob
};

enum class memory_type : uint32_t {
    buffer,
    image
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// MultiClassNms SortResultType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class SortResultType {
    CLASSID,  // sort selected boxes by class id (ascending) in each batch element
    SCORE,    // sort selected boxes by score (descending) in each batch element
    NONE      // do not guarantee the order in each batch element
};

}  // namespace kernel_selector
